/*
 ** Authored by Timothy Gerard Endres
 ** <mailto:time@gjt.org>  <http://www.trustice.com>
 **
 ** This work has been placed into the public domain.
 ** You may use this work in any way and for any purpose you wish.
 **
 ** THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY OF ANY KIND,
 ** NOT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY. THE AUTHOR
 ** OF THIS SOFTWARE, ASSUMES _NO_ RESPONSIBILITY FOR ANY
 ** CONSEQUENCE RESULTING FROM THE USE, MODIFICATION, OR
 ** REDISTRIBUTION OF THIS SOFTWARE.
 **
 */
package com.ice.tar;

import java.io.*;
import java.util.Date;

/**
 *
 * This class represents an entry in a Tar archive. It consists
 * of the entry's header, as well as the entry's File. Entries
 * can be instantiated in one of three ways, depending on how
 * they are to be used.
 * <p>
 * TarEntries that are created from the header bytes read from
 * an archive are instantiated with the TarEntry( byte[] )
 * constructor. These entries will be used when extracting from
 * or listing the contents of an archive. These entries have their
 * header filled in using the header bytes. They also set the File
 * to null, since they reference an archive entry not a file.
 * <p>
 * TarEntries that are created from Files that are to be written
 * into an archive are instantiated with the TarEntry( File )
 * constructor. These entries have their header filled in using
 * the File's information. They also keep a reference to the File
 * for convenience when writing entries.
 * <p>
 * Finally, TarEntries can be constructed from nothing but a name.
 * This allows the programmer to construct the entry by hand, for
 * instance when only an InputStream is available for writing to
 * the archive, and the header information is constructed from
 * other information. In this case the header fields are set to
 * defaults and the File is set to null.
 *
 * <pre>
 *
 * Original Unix Tar Header:
 *
 * Field  Field     Field
 * Width  Name      Meaning
 * -----  --------- ---------------------------
 *   100  name      name of file
 *     8  mode      file mode
 *     8  uid       owner user ID
 *     8  gid       owner group ID
 *    12  size      length of file in bytes
 *    12  mtime     modify time of file
 *     8  chksum    checksum for header
 *     1  link      indicator for links
 *   100  linkname  name of linked file
 *
 * </pre>
 *
 * <pre>
 *
 * POSIX "ustar" Style Tar Header:
 *
 * Field  Field     Field
 * Width  Name      Meaning
 * -----  --------- ---------------------------
 *   100  name      name of file
 *     8  mode      file mode
 *     8  uid       owner user ID
 *     8  gid       owner group ID
 *    12  size      length of file in bytes
 *    12  mtime     modify time of file
 *     8  chksum    checksum for header
 *     1  typeflag  type of file
 *   100  linkname  name of linked file
 *     6  magic     USTAR indicator
 *     2  version   USTAR version
 *    32  uname     owner user name
 *    32  gname     owner group name
 *     8  devmajor  device major number
 *     8  devminor  device minor number
 *   155  prefix    prefix for file name
 *
 * struct posix_header
 *   {                     byte offset
 *   char name[100];            0
 *   char mode[8];            100
 *   char uid[8];             108
 *   char gid[8];             116
 *   char size[12];           124
 *   char mtime[12];          136
 *   char chksum[8];          148
 *   char typeflag;           156
 *   char linkname[100];      157
 *   char magic[6];           257
 *   char version[2];         263
 *   char uname[32];          265
 *   char gname[32];          297
 *   char devmajor[8];        329
 *   char devminor[8];        337
 *   char prefix[155];        345
 *   };                       500
 *
 * </pre>
 *
 * Note that while the class does recognize GNU formatted headers,
 * it does not perform proper processing of GNU archives. I hope
 * to add the GNU support someday.
 *
 * Directory "size" fix contributed by:
 * Bert Becker <becker@informatik.hu-berlin.de>
 *
 * @see TarHeader
 * @author Timothy Gerard Endres, <time@gjt.org>
 */
public class TarEntry
        extends Object
        implements Cloneable {

    /**
     * If this entry represents a File, this references it.
     */
    protected File file;
    /**
     * This is the entry's header information.
     */
    protected TarHeader header;
    /**
     * Set to true if this is a "old-unix" format entry.
     */
    protected boolean unixFormat;
    /**
     * Set to true if this is a 'ustar' format entry.
     */
    protected boolean ustarFormat;
    /**
     * Set to true if this is a GNU 'ustar' format entry.
     */
    protected boolean gnuFormat;

    /**
     * The default constructor is protected for use only by subclasses.
     */
    protected TarEntry() {
    }

    /**
     * Construct an entry with only a name. This allows the programmer
     * to construct the entry's header "by hand". File is set to null.
     */
    public TarEntry(String name) {
        this.initialize();
        this.nameTarHeader(this.header, name);
    }

    /**
     * Construct an entry for a file. File is set to file, and the
     * header is constructed from information from the file.
     *
     * @param file The file that the entry represents.
     */
    public TarEntry(File file)
            throws InvalidHeaderException {
        this.initialize();
        this.getFileTarHeader(this.header, file);
    }

    /**
     * Construct an entry from an archive's header bytes. File is set
     * to null.
     *
     * @param headerBuf The header bytes from a tar archive entry.
     */
    public TarEntry(byte[] headerBuf)
            throws InvalidHeaderException {
        this.initialize();
        this.parseTarHeader(this.header, headerBuf);
    }

    /**
     * Initialization code common to all constructors.
     */
    private void initialize() {
        this.file = null;
        this.header = new TarHeader();

        this.gnuFormat = false;
        this.ustarFormat = true; // REVIEW What we prefer to use...
        this.unixFormat = false;
    }

    /**
     * Clone the entry.
     */
    public Object clone() {
        TarEntry entry = null;

        try {
            entry = (TarEntry) super.clone();

            if (this.header != null) {
                entry.header = (TarHeader) this.header.clone();
            }

            if (this.file != null) {
                entry.file = new File(this.file.getAbsolutePath());
            }
        } catch (CloneNotSupportedException ex) {
            ex.printStackTrace(System.err);
        }

        return entry;
    }

    /**
     * Returns true if this entry's header is in "ustar" format.
     *
     * @return True if the entry's header is in "ustar" format.
     */
    public boolean isUSTarFormat() {
        return this.ustarFormat;
    }

    /**
     * Sets this entry's header format to "ustar".
     */
    public void setUSTarFormat() {
        this.ustarFormat = true;
        this.gnuFormat = false;
        this.unixFormat = false;
    }

    /**
     * Returns true if this entry's header is in the GNU 'ustar' format.
     *
     * @return True if the entry's header is in the GNU 'ustar' format.
     */
    public boolean isGNUTarFormat() {
        return this.gnuFormat;
    }

    /**
     * Sets this entry's header format to GNU "ustar".
     */
    public void setGNUTarFormat() {
        this.gnuFormat = true;
        this.ustarFormat = false;
        this.unixFormat = false;
    }

    /**
     * Returns true if this entry's header is in the old "unix-tar" format.
     *
     * @return True if the entry's header is in the old "unix-tar" format.
     */
    public boolean isUnixTarFormat() {
        return this.unixFormat;
    }

    /**
     * Sets this entry's header format to "unix-style".
     */
    public void setUnixTarFormat() {
        this.unixFormat = true;
        this.ustarFormat = false;
        this.gnuFormat = false;
    }

    /**
     * Determine if the two entries are equal. Equality is determined
     * by the header names being equal.
     *
     * @return it Entry to be checked for equality.
     * @return True if the entries are equal.
     */
    public boolean equals(TarEntry it) {
        return this.header.name.toString().equals(it.header.name.toString());
    }

    /**
     * Determine if the given entry is a descendant of this entry.
     * Descendancy is determined by the name of the descendant
     * starting with this entry's name.
     *
     * @param desc Entry to be checked as a descendent of this.
     * @return True if entry is a descendant of this.
     */
    public boolean isDescendent(TarEntry desc) {
        return desc.header.name.toString().startsWith(this.header.name.toString());
    }

    /**
     * Get this entry's header.
     *
     * @return This entry's TarHeader.
     */
    public TarHeader getHeader() {
        return this.header;
    }

    /**
     * Get this entry's name.
     *
     * @return This entry's name.
     */
    public String getName() {
        return this.header.name.toString();
    }

    /**
     * Set this entry's name.
     *
     * @param name This entry's new name.
     */
    public void setName(String name) {
        this.header.name =
                new StringBuffer(name);
    }

    /**
     * Get this entry's user id.
     *
     * @return This entry's user id.
     */
    public int getUserId() {
        return this.header.userId;
    }

    /**
     * Set this entry's user id.
     *
     * @param userId This entry's new user id.
     */
    public void setUserId(int userId) {
        this.header.userId = userId;
    }

    /**
     * Get this entry's group id.
     *
     * @return This entry's group id.
     */
    public int getGroupId() {
        return this.header.groupId;
    }

    /**
     * Set this entry's group id.
     *
     * @param groupId This entry's new group id.
     */
    public void setGroupId(int groupId) {
        this.header.groupId = groupId;
    }

    /**
     * Get this entry's user name.
     *
     * @return This entry's user name.
     */
    public String getUserName() {
        return this.header.userName.toString();
    }

    /**
     * Set this entry's user name.
     *
     * @param userName This entry's new user name.
     */
    public void setUserName(String userName) {
        this.header.userName =
                new StringBuffer(userName);
    }

    /**
     * Get this entry's group name.
     *
     * @return This entry's group name.
     */
    public String getGroupName() {
        return this.header.groupName.toString();
    }

    /**
     * Set this entry's group name.
     *
     * @param groupName This entry's new group name.
     */
    public void setGroupName(String groupName) {
        this.header.groupName =
                new StringBuffer(groupName);
    }

    /**
     * Convenience method to set this entry's group and user ids.
     *
     * @param userId This entry's new user id.
     * @param groupId This entry's new group id.
     */
    public void setIds(int userId, int groupId) {
        this.setUserId(userId);
        this.setGroupId(groupId);
    }

    /**
     * Convenience method to set this entry's group and user names.
     *
     * @param userName This entry's new user name.
     * @param groupName This entry's new group name.
     */
    public void setNames(String userName, String groupName) {
        this.setUserName(userName);
        this.setGroupName(groupName);
    }

    /**
     * Set this entry's modification time. The parameter passed
     * to this method is in "Java time".
     *
     * @param time This entry's new modification time.
     */
    public void setModTime(long time) {
        this.header.modTime = time / 1000;
    }

    /**
     * Set this entry's modification time.
     *
     * @param time This entry's new modification time.
     */
    public void setModTime(Date time) {
        this.header.modTime = time.getTime() / 1000;
    }

    /**
     * Set this entry's modification time.
     *
     * @param time This entry's new modification time.
     */
    public Date getModTime() {
        return new Date(this.header.modTime * 1000);
    }

    /**
     * Get this entry's file.
     *
     * @return This entry's file.
     */
    public File getFile() {
        return this.file;
    }

    /**
     * Get this entry's file size.
     *
     * @return This entry's file size.
     */
    public long getSize() {
        return this.header.size;
    }

    /**
     * Set this entry's file size.
     *
     * @param size This entry's new file size.
     */
    public void setSize(long size) {
        this.header.size = size;
    }

    /**
     * Return whether or not this entry represents a directory.
     *
     * @return True if this entry is a directory.
     */
    public boolean isDirectory() {
        if (this.file != null) {
            return this.file.isDirectory();
        }

        if (this.header != null) {
            if (this.header.linkFlag == TarHeader.LF_DIR) {
                return true;
            }

            if (this.header.name.toString().endsWith("/")) {
                return true;
            }
        }

        return false;
    }

    /**
     * Fill in a TarHeader with information from a File.
     *
     * @param hdr The TarHeader to fill in.
     * @param file The file from which to get the header information.
     */
    public void getFileTarHeader(TarHeader hdr, File file)
            throws InvalidHeaderException {
        this.file = file;

        String name = file.getPath();
        String osname = System.getProperty("os.name");
        if (osname != null) {
            // Strip off drive letters!
            // REVIEW Would a better check be "(File.separator == '\')"?

            // String Win32Prefix = "Windows";
            // String prefix = osname.substring( 0, Win32Prefix.length() );
            // if ( prefix.equalsIgnoreCase( Win32Prefix ) )

            // if ( File.separatorChar == '\\' )

            // Windows OS check was contributed by
            // Patrick Beard <beard@netscape.com>
            String Win32Prefix = "windows";
            if (osname.toLowerCase().startsWith(Win32Prefix)) {
                if (name.length() > 2) {
                    char ch1 = name.charAt(0);
                    char ch2 = name.charAt(1);
                    if (ch2 == ':' && ((ch1 >= 'a' && ch1 <= 'z') || (ch1 >= 'A' && ch1 <= 'Z'))) {
                        name = name.substring(2);
                    }
                }
            }
        }

        name = name.replace(File.separatorChar, '/');

        // No absolute pathnames
        // Windows (and Posix?) paths can start with "\\NetworkDrive\",
        // so we loop on starting /'s.

        for (; name.startsWith("/");) {
            name = name.substring(1);
        }

        hdr.linkName = new StringBuffer("");

        hdr.name = new StringBuffer(name);

        if (file.isDirectory()) {
            hdr.size = 0;
            hdr.mode = 040755;
            hdr.linkFlag = TarHeader.LF_DIR;
            if (hdr.name.charAt(hdr.name.length() - 1) != '/') {
                hdr.name.append("/");
            }
        } else {
            hdr.size = file.length();
            hdr.mode = 0100644;
            hdr.linkFlag = TarHeader.LF_NORMAL;
        }

        // UNDONE When File lets us get the userName, use it!

        hdr.modTime = file.lastModified() / 1000;
        hdr.checkSum = 0;
        hdr.devMajor = 0;
        hdr.devMinor = 0;
    }

    /**
     * If this entry represents a file, and the file is a directory, return
     * an array of TarEntries for this entry's children.
     *
     * @return An array of TarEntry's for this entry's children.
     */
    public TarEntry[] getDirectoryEntries()
            throws InvalidHeaderException {
        if (this.file == null || !this.file.isDirectory()) {
            return new TarEntry[0];
        }

        String[] list = this.file.list();

        TarEntry[] result = new TarEntry[list.length];

        for (int i = 0; i < list.length; ++i) {
            result[i] =
                    new TarEntry(new File(this.file, list[i]));
        }

        return result;
    }

    /**
     * Compute the checksum of a tar entry header.
     *
     * @param buf The tar entry's header buffer.
     * @return The computed checksum.
     */
    public long computeCheckSum(byte[] buf) {
        long sum = 0;

        for (int i = 0; i < buf.length; ++i) {
            sum += 255 & buf[i];
        }

        return sum;
    }

    /**
     * Write an entry's header information to a header buffer.
     * This method can throw an InvalidHeaderException
     *
     * @param outbuf The tar entry header buffer to fill in.
     * @throws InvalidHeaderException If the name will not fit in the header.
     */
    public void writeEntryHeader(byte[] outbuf)
            throws InvalidHeaderException {
        int offset = 0;

        if (this.isUnixTarFormat()) {
            if (this.header.name.length() > 100) {
                throw new InvalidHeaderException("file path is greater than 100 characters, " + this.header.name);
            }
        }

        offset = TarHeader.getFileNameBytes(this.header.name.toString(), outbuf);

        offset = TarHeader.getOctalBytes(this.header.mode, outbuf, offset, TarHeader.MODELEN);

        offset = TarHeader.getOctalBytes(this.header.userId, outbuf, offset, TarHeader.UIDLEN);

        offset = TarHeader.getOctalBytes(this.header.groupId, outbuf, offset, TarHeader.GIDLEN);

        long size = this.header.size;

        offset = TarHeader.getLongOctalBytes(size, outbuf, offset, TarHeader.SIZELEN);

        offset = TarHeader.getLongOctalBytes(this.header.modTime, outbuf, offset, TarHeader.MODTIMELEN);

        int csOffset = offset;
        for (int c = 0; c < TarHeader.CHKSUMLEN; ++c) {
            outbuf[offset++] = (byte) ' ';
        }

        outbuf[offset++] = this.header.linkFlag;

        offset = TarHeader.getNameBytes(this.header.linkName, outbuf, offset, TarHeader.NAMELEN);

        if (this.unixFormat) {
            for (int i = 0; i < TarHeader.MAGICLEN; ++i) {
                outbuf[offset++] = 0;
            }
        } else {
            offset = TarHeader.getNameBytes(this.header.magic, outbuf, offset, TarHeader.MAGICLEN);
        }

        offset = TarHeader.getNameBytes(this.header.userName, outbuf, offset, TarHeader.UNAMELEN);

        offset = TarHeader.getNameBytes(this.header.groupName, outbuf, offset, TarHeader.GNAMELEN);

        offset = TarHeader.getOctalBytes(this.header.devMajor, outbuf, offset, TarHeader.DEVLEN);

        offset = TarHeader.getOctalBytes(this.header.devMinor, outbuf, offset, TarHeader.DEVLEN);

        for (; offset < outbuf.length;) {
            outbuf[offset++] = 0;
        }

        long checkSum = this.computeCheckSum(outbuf);

        TarHeader.getCheckSumOctalBytes(checkSum, outbuf, csOffset, TarHeader.CHKSUMLEN);
    }

    /**
     * Parse an entry's TarHeader information from a header buffer.
     *
     * Old unix-style code contributed by David Mehringer <dmehring@astro.uiuc.edu>.
     *
     * @param hdr The TarHeader to fill in from the buffer information.
     * @param header The tar entry header buffer to get information from.
     */
    public void parseTarHeader(TarHeader hdr, byte[] headerBuf)
            throws InvalidHeaderException {
        int offset = 0;

        //
        // NOTE Recognize archive header format.
        //
        if (headerBuf[257] == 0 && headerBuf[258] == 0 && headerBuf[259] == 0 && headerBuf[260] == 0 && headerBuf[261] == 0) {
            this.unixFormat = true;
            this.ustarFormat = false;
            this.gnuFormat = false;
        } else if (headerBuf[257] == 'u' && headerBuf[258] == 's' && headerBuf[259] == 't' && headerBuf[260] == 'a' && headerBuf[261] == 'r' && headerBuf[262] == 0) {
            this.ustarFormat = true;
            this.gnuFormat = false;
            this.unixFormat = false;
        } else if (headerBuf[257] == 'u' && headerBuf[258] == 's' && headerBuf[259] == 't' && headerBuf[260] == 'a' && headerBuf[261] == 'r' && headerBuf[262] != 0 && headerBuf[263] != 0) {
            // REVIEW
            this.gnuFormat = true;
            this.unixFormat = false;
            this.ustarFormat = false;
        } else {
            StringBuffer buf = new StringBuffer(128);

            buf.append("header magic is not 'ustar' or unix-style zeros, it is '");
            buf.append(headerBuf[257]);
            buf.append(headerBuf[258]);
            buf.append(headerBuf[259]);
            buf.append(headerBuf[260]);
            buf.append(headerBuf[261]);
            buf.append(headerBuf[262]);
            buf.append(headerBuf[263]);
            buf.append("', or (dec) ");
            buf.append((int) headerBuf[257]);
            buf.append(", ");
            buf.append((int) headerBuf[258]);
            buf.append(", ");
            buf.append((int) headerBuf[259]);
            buf.append(", ");
            buf.append((int) headerBuf[260]);
            buf.append(", ");
            buf.append((int) headerBuf[261]);
            buf.append(", ");
            buf.append((int) headerBuf[262]);
            buf.append(", ");
            buf.append((int) headerBuf[263]);

            throw new InvalidHeaderException(buf.toString());
        }

        hdr.name = TarHeader.parseFileName(headerBuf);

        offset = TarHeader.NAMELEN;

        hdr.mode = (int) TarHeader.parseOctal(headerBuf, offset, TarHeader.MODELEN);

        offset += TarHeader.MODELEN;

        hdr.userId = (int) TarHeader.parseOctal(headerBuf, offset, TarHeader.UIDLEN);

        offset += TarHeader.UIDLEN;

        hdr.groupId = (int) TarHeader.parseOctal(headerBuf, offset, TarHeader.GIDLEN);

        offset += TarHeader.GIDLEN;

        hdr.size =
                TarHeader.parseOctal(headerBuf, offset, TarHeader.SIZELEN);

        offset += TarHeader.SIZELEN;

        hdr.modTime =
                TarHeader.parseOctal(headerBuf, offset, TarHeader.MODTIMELEN);

        offset += TarHeader.MODTIMELEN;

        hdr.checkSum = (int) TarHeader.parseOctal(headerBuf, offset, TarHeader.CHKSUMLEN);

        offset += TarHeader.CHKSUMLEN;

        hdr.linkFlag = headerBuf[offset++];

        hdr.linkName =
                TarHeader.parseName(headerBuf, offset, TarHeader.NAMELEN);

        offset += TarHeader.NAMELEN;

        if (this.ustarFormat) {
            hdr.magic =
                    TarHeader.parseName(headerBuf, offset, TarHeader.MAGICLEN);

            offset += TarHeader.MAGICLEN;

            hdr.userName =
                    TarHeader.parseName(headerBuf, offset, TarHeader.UNAMELEN);

            offset += TarHeader.UNAMELEN;

            hdr.groupName =
                    TarHeader.parseName(headerBuf, offset, TarHeader.GNAMELEN);

            offset += TarHeader.GNAMELEN;

            hdr.devMajor = (int) TarHeader.parseOctal(headerBuf, offset, TarHeader.DEVLEN);

            offset += TarHeader.DEVLEN;

            hdr.devMinor = (int) TarHeader.parseOctal(headerBuf, offset, TarHeader.DEVLEN);
        } else {
            hdr.devMajor = 0;
            hdr.devMinor = 0;
            hdr.magic = new StringBuffer("");
            hdr.userName = new StringBuffer("");
            hdr.groupName = new StringBuffer("");
        }
    }

    /**
     * Fill in a TarHeader given only the entry's name.
     *
     * @param hdr The TarHeader to fill in.
     * @param name The tar entry name.
     */
    public void nameTarHeader(TarHeader hdr, String name) {
        boolean isDir = name.endsWith("/");

        this.gnuFormat = false;
        this.ustarFormat = true;
        this.unixFormat = false;

        hdr.checkSum = 0;
        hdr.devMajor = 0;
        hdr.devMinor = 0;

        hdr.name = new StringBuffer(name);
        hdr.mode = isDir ? 040755 : 0100644;
        hdr.userId = 0;
        hdr.groupId = 0;
        hdr.size = 0;
        hdr.checkSum = 0;

        hdr.modTime =
                (new java.util.Date()).getTime() / 1000;

        hdr.linkFlag =
                isDir ? TarHeader.LF_DIR : TarHeader.LF_NORMAL;

        hdr.linkName = new StringBuffer("");
        hdr.userName = new StringBuffer("");
        hdr.groupName = new StringBuffer("");

        hdr.devMajor = 0;
        hdr.devMinor = 0;
    }

    public String toString() {
        StringBuffer result = new StringBuffer(128);
        return result.append("[TarEntry name=").
                append(this.getName()).
                append(", isDir=").
                append(this.isDirectory()).
                append(", size=").
                append(this.getSize()).
                append(", userId=").
                append(this.getUserId()).
                append(", user=").
                append(this.getUserName()).
                append(", groupId=").
                append(this.getGroupId()).
                append(", group=").
                append(this.getGroupName()).
                append("]").
                toString();
    }
}

